home *** CD-ROM | disk | FTP | other *** search
/ Cre@te Online 2000 December / Cre@teOnline CD05.iso / MacSoft / XML ConsoleMax.sea / XML ConsoleMax / Required / xml4j.jar / com / ibm / xml / internal / UTF8Reader.class (.txt) < prev    next >
Encoding:
Java Class File  |  1999-08-30  |  16.8 KB  |  2,020 lines
  1. package com.ibm.xml.internal;
  2.  
  3. import com.ibm.xml.framework.ChunkyCharArray;
  4. import com.ibm.xml.framework.ParserState;
  5. import com.ibm.xml.framework.ScanContentState;
  6. import com.ibm.xml.framework.StringPool;
  7. import com.ibm.xml.framework.XMLDocumentHandler;
  8. import com.ibm.xml.framework.XMLErrorHandler;
  9. import com.ibm.xml.framework.XMLReader;
  10. import com.ibm.xml.framework.XMLScanner;
  11. import java.io.InputStream;
  12.  
  13. final class UTF8Reader extends XMLReader {
  14.    protected static final int CHUNK_SHIFT = 14;
  15.    protected static final int CHUNK_SIZE = 16384;
  16.    protected static final int CHUNK_MASK = 16383;
  17.    protected char[] fCharacters = new char[256];
  18.    protected int fCharDataLength;
  19.    protected XMLScanner fScanner;
  20.    protected StringPool fStringPool;
  21.    protected XMLDocumentHandler fDocumentHandler;
  22.    protected boolean fSendCharDataAsCharArray = false;
  23.    protected XMLErrorHandler fErrorHandler;
  24.    protected InputStream fInputStream;
  25.    protected UTF8DataChunk fCurrentChunk;
  26.    protected int fCurrentIndex;
  27.    protected byte[] fMostRecentData;
  28.    protected int fMostRecentByte;
  29.    protected int fLength;
  30.    protected boolean fCheckOverflow = false;
  31.    protected byte[] fOverflow;
  32.    protected int fOverflowOffset;
  33.    protected int fOverflowEnd;
  34.    protected boolean fSkipLinefeed = false;
  35.    protected int fPartialMultiByteIn;
  36.    protected byte[] fPartialMultiByteChar = new byte[4];
  37.    protected boolean fPartialMultiByteResult = false;
  38.    protected int fFastCopyCount;
  39.    protected int fOutputOffset;
  40.    protected int fPartialMultiByteOut;
  41.  
  42.    UTF8Reader(ParserState var1, String var2, String var3, InputStream var4) throws Exception {
  43.       super(var1, var2, var3);
  44.       this.fInputStream = var4;
  45.       this.fScanner = var1.getScanner();
  46.       this.fStringPool = var1.cacheStringPool();
  47.       this.fDocumentHandler = var1.getDocumentHandler();
  48.       this.fSendCharDataAsCharArray = this.fDocumentHandler != null && this.fDocumentHandler.sendCharDataAsCharArray();
  49.       this.fErrorHandler = var1.getErrorHandler();
  50.       this.fCurrentChunk = new UTF8DataChunk(this, this.fStringPool, (UTF8DataChunk)null);
  51.       this.fillCurrentChunk();
  52.    }
  53.  
  54.    public int addString(int var1, int var2) {
  55.       return var2 == 0 ? 0 : this.fCurrentChunk.addString(var1, var2);
  56.    }
  57.  
  58.    public int addSymbol(int var1, int var2) {
  59.       return var2 == 0 ? 0 : this.fCurrentChunk.addSymbol(var1, var2, 0);
  60.    }
  61.  
  62.    protected int addSymbol(int var1, int var2, int var3) {
  63.       return this.fCurrentChunk.addSymbol(var1, var2, var3);
  64.    }
  65.  
  66.    public void append(ChunkyCharArray var1, int var2, int var3) {
  67.       this.fCurrentChunk.append(var1, var2, var3);
  68.    }
  69.  
  70.    protected int slowLoadNextByte() throws Exception {
  71.       if (this.fCurrentChunk.nextChunk() != null) {
  72.          this.fCurrentChunk = this.fCurrentChunk.nextChunk();
  73.          this.fCurrentIndex = 0;
  74.          this.fMostRecentData = this.fCurrentChunk.toByteArray();
  75.          return this.fMostRecentByte = this.fMostRecentData[this.fCurrentIndex] & 255;
  76.       } else {
  77.          this.fCurrentChunk = new UTF8DataChunk(this, this.fStringPool, this.fCurrentChunk);
  78.          return this.fillCurrentChunk();
  79.       }
  80.    }
  81.  
  82.    protected int loadNextByte() throws Exception {
  83.       ++super.fCurrentOffset;
  84.       return ++this.fCurrentIndex == 16384 ? this.slowLoadNextByte() : (this.fMostRecentByte = this.fMostRecentData[this.fCurrentIndex] & 255);
  85.    }
  86.  
  87.    protected void checkEOF(int var1) {
  88.       if (var1 > this.fLength) {
  89.          throw new ArrayIndexOutOfBoundsException();
  90.       }
  91.    }
  92.  
  93.    protected void skipOneCharStartingWithByte(int var1) throws Exception {
  94.       if ((128 & var1) == 0) {
  95.          if (var1 == 0) {
  96.             int var2 = super.fCurrentOffset + 1;
  97.             if (var2 > this.fLength) {
  98.                throw new ArrayIndexOutOfBoundsException();
  99.             } else {
  100.                ++super.fCharacterCounter;
  101.             }
  102.          } else if (var1 == 10) {
  103.             ++super.fLinefeedCounter;
  104.             super.fCharacterCounter = 1;
  105.          } else {
  106.             ++super.fCharacterCounter;
  107.          }
  108.       } else {
  109.          ++super.fCharacterCounter;
  110.          this.loadNextByte();
  111.          if ((224 & var1) != 192) {
  112.             this.loadNextByte();
  113.             if ((240 & var1) != 224) {
  114.                this.loadNextByte();
  115.             }
  116.          }
  117.       }
  118.    }
  119.  
  120.    public int skipOneChar() throws Exception {
  121.       int var1 = this.fMostRecentByte;
  122.       this.skipOneCharStartingWithByte(var1);
  123.       this.loadNextByte();
  124.       return super.fCurrentOffset;
  125.    }
  126.  
  127.    public int skipAsciiChar() throws Exception {
  128.       ++super.fCharacterCounter;
  129.       this.loadNextByte();
  130.       return super.fCurrentOffset;
  131.    }
  132.  
  133.    public int skipToChar(char var1) throws Exception {
  134.       for(int var2 = this.fMostRecentByte; var2 != var1; var2 = this.loadNextByte()) {
  135.          this.skipOneCharStartingWithByte(var2);
  136.       }
  137.  
  138.       return super.fCurrentOffset;
  139.    }
  140.  
  141.    public int skipPastChar(char var1) throws Exception {
  142.       for(int var2 = this.fMostRecentByte; var2 != var1; var2 = this.loadNextByte()) {
  143.          this.skipOneCharStartingWithByte(var2);
  144.       }
  145.  
  146.       ++super.fCharacterCounter;
  147.       this.loadNextByte();
  148.       return super.fCurrentOffset;
  149.    }
  150.  
  151.    public boolean skippedValidChar() throws Exception {
  152.       int var1 = this.fMostRecentByte;
  153.       if ((128 & var1) == 0) {
  154.          if (var1 < 32 && var1 != 9) {
  155.             if (var1 == 10) {
  156.                ++super.fLinefeedCounter;
  157.                super.fCharacterCounter = 1;
  158.                this.loadNextByte();
  159.                return true;
  160.             } else {
  161.                if (var1 == 0) {
  162.                   int var7 = super.fCurrentOffset + 1;
  163.                   if (var7 > this.fLength) {
  164.                      throw new ArrayIndexOutOfBoundsException();
  165.                   }
  166.                }
  167.  
  168.                return false;
  169.             }
  170.          } else {
  171.             ++super.fCharacterCounter;
  172.             this.loadNextByte();
  173.             return true;
  174.          }
  175.       } else {
  176.          UTF8DataChunk var2 = this.fCurrentChunk;
  177.          int var3 = this.fCurrentIndex;
  178.          int var4 = super.fCurrentOffset;
  179.          int var5 = this.loadNextByte();
  180.          if ((224 & var1) == 192) {
  181.             ++super.fCharacterCounter;
  182.             this.loadNextByte();
  183.             return true;
  184.          } else {
  185.             int var6 = this.loadNextByte();
  186.             if ((240 & var1) == 224) {
  187.                if (var1 == 237 && var5 >= 160 || var1 == 239 && var5 == 191 && var6 >= 190) {
  188.                   this.fCurrentChunk = var2;
  189.                   this.fCurrentIndex = var3;
  190.                   super.fCurrentOffset = var4;
  191.                   this.fMostRecentData = var2.toByteArray();
  192.                   this.fMostRecentByte = var1;
  193.                   return false;
  194.                } else {
  195.                   ++super.fCharacterCounter;
  196.                   this.loadNextByte();
  197.                   return true;
  198.                }
  199.             } else {
  200.                this.loadNextByte();
  201.                if (var1 > 244 || var1 == 244 && var5 >= 144) {
  202.                   this.fCurrentChunk = var2;
  203.                   this.fCurrentIndex = var3;
  204.                   super.fCurrentOffset = var4;
  205.                   this.fMostRecentData = var2.toByteArray();
  206.                   this.fMostRecentByte = var1;
  207.                   return false;
  208.                } else {
  209.                   ++super.fCharacterCounter;
  210.                   this.loadNextByte();
  211.                   return true;
  212.                }
  213.             }
  214.          }
  215.       }
  216.    }
  217.  
  218.    public boolean lookingAtValidChar() throws Exception {
  219.       int var1 = this.fMostRecentByte;
  220.       if ((128 & var1) == 0) {
  221.          if (var1 < 32 && var1 != 9 && var1 != 10) {
  222.             if (var1 == 0) {
  223.                int var7 = super.fCurrentOffset + 1;
  224.                if (var7 > this.fLength) {
  225.                   throw new ArrayIndexOutOfBoundsException();
  226.                }
  227.             }
  228.  
  229.             return false;
  230.          } else {
  231.             return true;
  232.          }
  233.       } else {
  234.          UTF8DataChunk var2 = this.fCurrentChunk;
  235.          int var3 = this.fCurrentIndex;
  236.          int var4 = super.fCurrentOffset;
  237.          int var5 = this.loadNextByte();
  238.          if ((224 & var1) == 192) {
  239.             this.fCurrentChunk = var2;
  240.             this.fCurrentIndex = var3;
  241.             super.fCurrentOffset = var4;
  242.             this.fMostRecentData = var2.toByteArray();
  243.             this.fMostRecentByte = var1;
  244.             return true;
  245.          } else {
  246.             int var6 = this.loadNextByte();
  247.             if ((240 & var1) == 224) {
  248.                this.fCurrentChunk = var2;
  249.                this.fCurrentIndex = var3;
  250.                super.fCurrentOffset = var4;
  251.                this.fMostRecentData = var2.toByteArray();
  252.                this.fMostRecentByte = var1;
  253.                return (var1 != 237 || var5 < 160) && (var1 != 239 || var5 != 191 || var6 < 190);
  254.             } else {
  255.                this.loadNextByte();
  256.                this.fCurrentChunk = var2;
  257.                this.fCurrentIndex = var3;
  258.                super.fCurrentOffset = var4;
  259.                this.fMostRecentData = var2.toByteArray();
  260.                this.fMostRecentByte = var1;
  261.                return var1 <= 244 && (var1 != 244 || var5 < 144);
  262.             }
  263.          }
  264.       }
  265.    }
  266.  
  267.    public int skipInvalidChar(int var1) throws Exception {
  268.       int var3 = this.fMostRecentByte;
  269.       ++super.fCharacterCounter;
  270.       int var2;
  271.       if ((var3 & 128) == 0) {
  272.          var2 = var3;
  273.       } else {
  274.          int var4 = this.loadNextByte();
  275.          if ((224 & var3) == 192) {
  276.             var2 = ((31 & var3) << 6) + (63 & var4);
  277.          } else {
  278.             int var5 = this.loadNextByte();
  279.             if ((240 & var3) == 224) {
  280.                var2 = ((15 & var3) << 12) + ((63 & var4) << 6) + (63 & var5);
  281.             } else {
  282.                int var6 = this.loadNextByte();
  283.                var2 = ((15 & var3) << 18) + ((63 & var4) << 12) + ((63 & var5) << 6) + (63 & var6);
  284.             }
  285.          }
  286.       }
  287.  
  288.       switch (var1) {
  289.          case 43:
  290.             String var9 = (new Character((char)var2)).toString();
  291.             String var10 = Integer.toHexString(var2);
  292.             this.fErrorHandler.error2(var1, this.fStringPool.addString(var9), this.fStringPool.addString(var10));
  293.             break;
  294.          case 63:
  295.          case 85:
  296.             String var8 = Integer.toHexString(var2);
  297.             this.fErrorHandler.error1(var1, this.fStringPool.addString(var8));
  298.             break;
  299.          case 80:
  300.          case 82:
  301.          case 110:
  302.             String var7 = (new Character((char)var2)).toString();
  303.             this.fErrorHandler.error1(var1, this.fStringPool.addString(var7));
  304.       }
  305.  
  306.       this.loadNextByte();
  307.       return super.fCurrentOffset;
  308.    }
  309.  
  310.    public boolean skippedChar(char var1) throws Exception {
  311.       int var2 = this.fMostRecentByte;
  312.       if (var2 != var1) {
  313.          return false;
  314.       } else {
  315.          ++super.fCharacterCounter;
  316.          ++super.fCurrentOffset;
  317.          if (++this.fCurrentIndex == 16384) {
  318.             this.slowLoadNextByte();
  319.          } else {
  320.             this.fMostRecentByte = this.fMostRecentData[this.fCurrentIndex] & 255;
  321.          }
  322.  
  323.          return true;
  324.       }
  325.    }
  326.  
  327.    public boolean lookingAtChar(char var1) {
  328.       int var2 = this.fMostRecentByte;
  329.       return var2 == var1;
  330.    }
  331.  
  332.    public boolean skippedSpace() throws Exception {
  333.       int var1 = this.fMostRecentByte;
  334.       if (var1 > 32) {
  335.          return false;
  336.       } else {
  337.          if (var1 != 32 && var1 != 9) {
  338.             if (var1 != 10) {
  339.                return false;
  340.             }
  341.  
  342.             ++super.fLinefeedCounter;
  343.             super.fCharacterCounter = 1;
  344.          } else {
  345.             ++super.fCharacterCounter;
  346.          }
  347.  
  348.          ++super.fCurrentOffset;
  349.          if (++this.fCurrentIndex == 16384) {
  350.             this.slowLoadNextByte();
  351.          } else {
  352.             this.fMostRecentByte = this.fMostRecentData[this.fCurrentIndex] & 255;
  353.          }
  354.  
  355.          return true;
  356.       }
  357.    }
  358.  
  359.    public boolean lookingAtSpace() {
  360.       int var1 = this.fMostRecentByte;
  361.       return var1 == 32 || var1 == 9 || var1 == 10;
  362.    }
  363.  
  364.    public int skipPastSpaces() throws Exception {
  365.       int var1 = this.fMostRecentByte;
  366.  
  367.       while(true) {
  368.          if (var1 != 32 && var1 != 9) {
  369.             if (var1 != 10) {
  370.                return super.fCurrentOffset;
  371.             }
  372.  
  373.             ++super.fLinefeedCounter;
  374.             super.fCharacterCounter = 1;
  375.          } else {
  376.             ++super.fCharacterCounter;
  377.          }
  378.  
  379.          var1 = this.loadNextByte();
  380.       }
  381.    }
  382.  
  383.    public int skipDecimalDigit() throws Exception {
  384.       int var1 = this.fMostRecentByte;
  385.       if (var1 >= 48 && var1 <= 57) {
  386.          ++super.fCharacterCounter;
  387.          this.loadNextByte();
  388.          return var1 - 48;
  389.       } else {
  390.          return -1;
  391.       }
  392.    }
  393.  
  394.    public int skipHexDigit() throws Exception {
  395.       int var1 = this.fMostRecentByte;
  396.       if (var1 <= 102 && XMLReader.fgAsciiXDigitChar[var1] != 0) {
  397.          ++super.fCharacterCounter;
  398.          this.loadNextByte();
  399.          return var1 - (var1 < 65 ? 48 : (var1 < 97 ? 65 : 97) - 10);
  400.       } else {
  401.          return -1;
  402.       }
  403.    }
  404.  
  405.    public boolean skippedAlpha() throws Exception {
  406.       int var1 = this.fMostRecentByte;
  407.       if (var1 <= 122 && XMLReader.fgAsciiAlphaChar[var1] != 0) {
  408.          ++super.fCharacterCounter;
  409.          this.loadNextByte();
  410.          return true;
  411.       } else {
  412.          return false;
  413.       }
  414.    }
  415.  
  416.    protected final boolean skippedAsciiCharWithFlag(byte var1) throws Exception {
  417.       int var2 = this.fMostRecentByte;
  418.       if ((var2 & 128) == 0 && (XMLReader.fgCharFlags[var2] & var1) != 0) {
  419.          ++super.fCharacterCounter;
  420.          this.loadNextByte();
  421.          return true;
  422.       } else {
  423.          return false;
  424.       }
  425.    }
  426.  
  427.    public final boolean skippedVersionNum() throws Exception {
  428.       return this.skippedAsciiCharWithFlag((byte)1);
  429.    }
  430.  
  431.    public final boolean skippedEncName() throws Exception {
  432.       return this.skippedAsciiCharWithFlag((byte)2);
  433.    }
  434.  
  435.    public final boolean skippedPubidChar() throws Exception {
  436.       int var1 = this.fMostRecentByte;
  437.       if ((var1 & 128) != 0) {
  438.          return false;
  439.       } else if ((XMLReader.fgCharFlags[var1] & 4) != 0) {
  440.          ++super.fCharacterCounter;
  441.          this.loadNextByte();
  442.          return true;
  443.       } else if (var1 == 10) {
  444.          ++super.fLinefeedCounter;
  445.          super.fCharacterCounter = 1;
  446.          this.loadNextByte();
  447.          return true;
  448.       } else {
  449.          return false;
  450.       }
  451.    }
  452.  
  453.    public boolean skippedString(char[] var1) throws Exception {
  454.       int var2 = var1.length;
  455.       byte[] var3 = this.fMostRecentData;
  456.       int var4 = this.fCurrentIndex;
  457.       if (var4 + var2 <= 16384) {
  458.          for(int var11 = 0; var11 < var2; ++var11) {
  459.             if (var3[var4++] != var1[var11]) {
  460.                return false;
  461.             }
  462.          }
  463.  
  464.          super.fCharacterCounter += var2;
  465.          super.fCurrentOffset += var2;
  466.          this.fCurrentIndex = var4;
  467.          if (var4 == 16384) {
  468.             this.slowLoadNextByte();
  469.          } else {
  470.             this.fMostRecentByte = var3[var4] & 255;
  471.          }
  472.  
  473.          return true;
  474.       } else {
  475.          UTF8DataChunk var5 = this.fCurrentChunk;
  476.          int var6 = super.fCurrentOffset;
  477.          int var7 = var4;
  478.          int var8 = 0;
  479.  
  480.          while(var4 < 16384) {
  481.             if (var3[var4++] != var1[var8++]) {
  482.                return false;
  483.             }
  484.          }
  485.  
  486.          this.slowLoadNextByte();
  487.          var3 = this.fMostRecentData;
  488.          var4 = 0;
  489.  
  490.          while(var8 < var2) {
  491.             if (var3[var4++] != var1[var8++]) {
  492.                this.fCurrentChunk = var5;
  493.                this.fCurrentIndex = var7;
  494.                super.fCurrentOffset = var6;
  495.                this.fMostRecentData = var5.toByteArray();
  496.                this.fMostRecentByte = this.fMostRecentData[var7] & 255;
  497.                return false;
  498.             }
  499.          }
  500.  
  501.          super.fCharacterCounter += var2;
  502.          super.fCurrentOffset += var2;
  503.          this.fCurrentIndex = var4;
  504.          if (var4 == 16384) {
  505.             this.slowLoadNextByte();
  506.          } else {
  507.             this.fMostRecentByte = var3[var4] & 255;
  508.          }
  509.  
  510.          return true;
  511.       }
  512.    }
  513.  
  514.    public int scanName(char var1, int var2) throws Exception {
  515.       int var3 = super.fCurrentOffset;
  516.       byte[] var4 = this.fMostRecentData;
  517.       int var5 = this.fMostRecentByte;
  518.       int var6;
  519.       if ((var5 & 128) == 0) {
  520.          if (XMLReader.fgAsciiInitialNameChar[var5] == 0) {
  521.             return -1;
  522.          }
  523.  
  524.          var6 = var5;
  525.       } else {
  526.          UTF8DataChunk var7 = this.fCurrentChunk;
  527.          int var8 = this.fCurrentIndex;
  528.          ++super.fCurrentOffset;
  529.          if (++this.fCurrentIndex == 16384) {
  530.             this.fCurrentChunk = new UTF8DataChunk(this, this.fStringPool, this.fCurrentChunk);
  531.             this.fillCurrentChunk();
  532.             var4 = this.fMostRecentData;
  533.          }
  534.  
  535.          int var9 = var4[this.fCurrentIndex] & 255;
  536.          if ((224 & var5) == 192) {
  537.             var6 = ((31 & var5) << 6) + (63 & var9);
  538.             if ((XMLReader.fgCharFlags[var6] & 16) == 0) {
  539.                this.fCurrentChunk = var7;
  540.                this.fCurrentIndex = var8;
  541.                super.fCurrentOffset = var3;
  542.                this.fMostRecentData = var7.toByteArray();
  543.                this.fMostRecentByte = var5;
  544.                return -1;
  545.             }
  546.          } else {
  547.             ++super.fCurrentOffset;
  548.             if (++this.fCurrentIndex == 16384) {
  549.                this.fCurrentChunk = new UTF8DataChunk(this, this.fStringPool, this.fCurrentChunk);
  550.                this.fillCurrentChunk();
  551.                var4 = this.fMostRecentData;
  552.             }
  553.  
  554.             int var10 = var4[this.fCurrentIndex] & 255;
  555.             if ((240 & var5) != 224) {
  556.                this.fCurrentChunk = var7;
  557.                this.fCurrentIndex = var8;
  558.                super.fCurrentOffset = var3;
  559.                this.fMostRecentData = var7.toByteArray();
  560.                this.fMostRecentByte = var5;
  561.                return -1;
  562.             }
  563.  
  564.             if (var5 == 237 && var9 >= 160 || var5 == 239 && var9 == 191 && var10 >= 190) {
  565.                this.fCurrentChunk = var7;
  566.                this.fCurrentIndex = var8;
  567.                super.fCurrentOffset = var3;
  568.                this.fMostRecentData = var7.toByteArray();
  569.                this.fMostRecentByte = var5;
  570.                return -1;
  571.             }
  572.  
  573.             var6 = ((15 & var5) << 12) + ((63 & var9) << 6) + (63 & var10);
  574.             if ((XMLReader.fgCharFlags[var6] & 16) == 0) {
  575.                this.fCurrentChunk = var7;
  576.                this.fCurrentIndex = var8;
  577.                super.fCurrentOffset = var3;
  578.                this.fMostRecentData = var7.toByteArray();
  579.                this.fMostRecentByte = var5;
  580.                return -1;
  581.             }
  582.          }
  583.       }
  584.  
  585.       int var15 = 0;
  586.       int var17 = 0;
  587.  
  588.       while(true) {
  589.          var15 = StringHasher.hashChar(var15, var17++, var6);
  590.          ++super.fCharacterCounter;
  591.          ++super.fCurrentOffset;
  592.          if (++this.fCurrentIndex == 16384) {
  593.             this.fCurrentChunk = new UTF8DataChunk(this, this.fStringPool, this.fCurrentChunk);
  594.             this.fillCurrentChunk();
  595.             var4 = this.fMostRecentData;
  596.          }
  597.  
  598.          var5 = var4[this.fCurrentIndex] & 255;
  599.          if (var1 == var5) {
  600.             break;
  601.          }
  602.  
  603.          if ((var5 & 128) == 0) {
  604.             if (XMLReader.fgAsciiNameChar[var5] == 0) {
  605.                break;
  606.             }
  607.  
  608.             var6 = var5;
  609.          } else {
  610.             UTF8DataChunk var18 = this.fCurrentChunk;
  611.             int var20 = super.fCurrentOffset;
  612.             int var11 = this.fCurrentIndex;
  613.             ++super.fCurrentOffset;
  614.             if (++this.fCurrentIndex == 16384) {
  615.                this.fCurrentChunk = new UTF8DataChunk(this, this.fStringPool, this.fCurrentChunk);
  616.                this.fillCurrentChunk();
  617.                var4 = this.fMostRecentData;
  618.             }
  619.  
  620.             int var12 = var4[this.fCurrentIndex] & 255;
  621.             if ((224 & var5) == 192) {
  622.                var6 = ((31 & var5) << 6) + (63 & var12);
  623.                if ((XMLReader.fgCharFlags[var6] & 32) == 0) {
  624.                   this.fCurrentChunk = var18;
  625.                   this.fCurrentIndex = var11;
  626.                   super.fCurrentOffset = var20;
  627.                   this.fMostRecentData = var18.toByteArray();
  628.                   break;
  629.                }
  630.             } else {
  631.                ++super.fCurrentOffset;
  632.                if (++this.fCurrentIndex == 16384) {
  633.                   this.fCurrentChunk = new UTF8DataChunk(this, this.fStringPool, this.fCurrentChunk);
  634.                   this.fillCurrentChunk();
  635.                   var4 = this.fMostRecentData;
  636.                }
  637.  
  638.                int var13 = var4[this.fCurrentIndex] & 255;
  639.                if ((240 & var5) != 224) {
  640.                   this.fCurrentChunk = var18;
  641.                   this.fCurrentIndex = var11;
  642.                   super.fCurrentOffset = var20;
  643.                   this.fMostRecentData = var18.toByteArray();
  644.                   break;
  645.                }
  646.  
  647.                if ((var5 != 237 || var12 < 160) && (var5 != 239 || var12 != 191 || var13 < 190)) {
  648.                   var6 = ((15 & var5) << 12) + ((63 & var12) << 6) + (63 & var13);
  649.                   if ((XMLReader.fgCharFlags[var6] & 32) != 0) {
  650.                      continue;
  651.                   }
  652.  
  653.                   this.fCurrentChunk = var18;
  654.                   this.fCurrentIndex = var11;
  655.                   super.fCurrentOffset = var20;
  656.                   this.fMostRecentData = var18.toByteArray();
  657.                   break;
  658.                }
  659.  
  660.                this.fCurrentChunk = var18;
  661.                this.fCurrentIndex = var11;
  662.                super.fCurrentOffset = var20;
  663.                this.fMostRecentData = var18.toByteArray();
  664.                break;
  665.             }
  666.          }
  667.       }
  668.  
  669.       this.fMostRecentByte = var5;
  670.       var15 = StringHasher.finishHash(var15);
  671.       int var19 = super.fCurrentOffset - var3;
  672.       int var21 = this.fCurrentChunk.addSymbol(var3, var19, var15);
  673.       if (var2 != -1 && var2 != var21) {
  674.          return -1;
  675.       } else {
  676.          return var21;
  677.       }
  678.    }
  679.  
  680.    protected boolean skippedMultiByteCharWithFlag(int var1, int var2) throws Exception {
  681.       UTF8DataChunk var3 = this.fCurrentChunk;
  682.       int var4 = super.fCurrentOffset;
  683.       int var5 = this.fCurrentIndex;
  684.       int var6 = this.loadNextByte();
  685.       if ((224 & var1) == 192) {
  686.          if ((XMLReader.fgCharFlags[((31 & var1) << 6) + (63 & var6)] & var2) == 0) {
  687.             this.fCurrentChunk = var3;
  688.             this.fCurrentIndex = var5;
  689.             super.fCurrentOffset = var4;
  690.             this.fMostRecentData = var3.toByteArray();
  691.             this.fMostRecentByte = var1;
  692.             return false;
  693.          } else {
  694.             return true;
  695.          }
  696.       } else {
  697.          int var7 = this.loadNextByte();
  698.          if ((240 & var1) != 224) {
  699.             this.fCurrentChunk = var3;
  700.             this.fCurrentIndex = var5;
  701.             super.fCurrentOffset = var4;
  702.             this.fMostRecentData = var3.toByteArray();
  703.             this.fMostRecentByte = var1;
  704.             return false;
  705.          } else if ((var1 != 237 || var6 < 160) && (var1 != 239 || var6 != 191 || var7 < 190)) {
  706.             if ((XMLReader.fgCharFlags[((15 & var1) << 12) + ((63 & var6) << 6) + (63 & var7)] & var2) == 0) {
  707.                this.fCurrentChunk = var3;
  708.                this.fCurrentIndex = var5;
  709.                super.fCurrentOffset = var4;
  710.                this.fMostRecentData = var3.toByteArray();
  711.                this.fMostRecentByte = var1;
  712.                return false;
  713.             } else {
  714.                return true;
  715.             }
  716.          } else {
  717.             this.fCurrentChunk = var3;
  718.             this.fCurrentIndex = var5;
  719.             super.fCurrentOffset = var4;
  720.             this.fMostRecentData = var3.toByteArray();
  721.             this.fMostRecentByte = var1;
  722.             return false;
  723.          }
  724.       }
  725.    }
  726.  
  727.    public int skipPastName(char var1) throws Exception {
  728.       int var2 = this.fMostRecentByte;
  729.       if ((var2 & 128) == 0) {
  730.          if (XMLReader.fgAsciiInitialNameChar[var2] == 0) {
  731.             return super.fCurrentOffset;
  732.          }
  733.       } else if (!this.skippedMultiByteCharWithFlag(var2, 16)) {
  734.          return super.fCurrentOffset;
  735.       }
  736.  
  737.       while(true) {
  738.          ++super.fCharacterCounter;
  739.          var2 = this.loadNextByte();
  740.          if (var1 == var2) {
  741.             return super.fCurrentOffset;
  742.          }
  743.  
  744.          if ((var2 & 128) == 0) {
  745.             if (XMLReader.fgAsciiNameChar[var2] == 0) {
  746.                return super.fCurrentOffset;
  747.             }
  748.          } else if (!this.skippedMultiByteCharWithFlag(var2, 32)) {
  749.             return super.fCurrentOffset;
  750.          }
  751.       }
  752.    }
  753.  
  754.    public int skipPastNmtoken(char var1) throws Exception {
  755.       for(int var2 = this.fMostRecentByte; var1 != var2; var2 = this.loadNextByte()) {
  756.          if ((var2 & 128) == 0) {
  757.             if (XMLReader.fgAsciiNameChar[var2] == 0) {
  758.                return super.fCurrentOffset;
  759.             }
  760.          } else if (!this.skippedMultiByteCharWithFlag(var2, 32)) {
  761.             return super.fCurrentOffset;
  762.          }
  763.  
  764.          ++super.fCharacterCounter;
  765.       }
  766.  
  767.       return super.fCurrentOffset;
  768.    }
  769.  
  770.    public int scanContent(ScanContentState var1) throws Exception {
  771.       int var2;
  772.       int var4;
  773.       label326: {
  774.          label343: {
  775.             this.fCurrentChunk.clearPreviousChunk();
  776.             this.fCharDataLength = 0;
  777.             var2 = super.fCurrentOffset;
  778.             int var3 = this.fMostRecentByte;
  779.             if ((var3 & 128) != 0) {
  780.                if (!this.skipMultiByteCharData(var3)) {
  781.                   return 4;
  782.                }
  783.             } else {
  784.                switch (XMLReader.fgAsciiWSCharData[var3]) {
  785.                   case 0:
  786.                      ++super.fCharacterCounter;
  787.                      ++super.fCurrentOffset;
  788.                      if (++this.fCurrentIndex == 16384) {
  789.                         this.slowLoadNextByte();
  790.                      } else {
  791.                         this.fMostRecentByte = this.fMostRecentData[this.fCurrentIndex] & 255;
  792.                      }
  793.  
  794.                      if (this.fSendCharDataAsCharArray) {
  795.                         this.appendCharData(var3);
  796.                      }
  797.                      break;
  798.                   case 1:
  799.                      ++super.fCharacterCounter;
  800.                      ++super.fCurrentOffset;
  801.                      if (++this.fCurrentIndex == 16384) {
  802.                         this.slowLoadNextByte();
  803.                      } else {
  804.                         this.fMostRecentByte = this.fMostRecentData[this.fCurrentIndex] & 255;
  805.                      }
  806.  
  807.                      if (!var1.inCDSect) {
  808.                         return 1;
  809.                      }
  810.  
  811.                      if (this.fSendCharDataAsCharArray) {
  812.                         this.appendCharData(60);
  813.                      }
  814.                      break;
  815.                   case 2:
  816.                      ++super.fCharacterCounter;
  817.                      ++super.fCurrentOffset;
  818.                      if (++this.fCurrentIndex == 16384) {
  819.                         this.slowLoadNextByte();
  820.                      } else {
  821.                         this.fMostRecentByte = this.fMostRecentData[this.fCurrentIndex] & 255;
  822.                      }
  823.  
  824.                      if (!var1.inCDSect) {
  825.                         return 2;
  826.                      }
  827.  
  828.                      if (this.fSendCharDataAsCharArray) {
  829.                         this.appendCharData(38);
  830.                      }
  831.                      break;
  832.                   case 3:
  833.                      ++super.fCharacterCounter;
  834.                      var3 = this.loadNextByte();
  835.                      if (var3 != 93) {
  836.                         if (this.fSendCharDataAsCharArray) {
  837.                            this.appendCharData(93);
  838.                         }
  839.                      } else if (this.fCurrentIndex + 1 == 16384) {
  840.                         UTF8DataChunk var11 = this.fCurrentChunk;
  841.                         int var13 = this.fCurrentIndex;
  842.                         int var15 = super.fCurrentOffset;
  843.                         if (this.loadNextByte() == 62) {
  844.                            break label343;
  845.                         }
  846.  
  847.                         this.fCurrentChunk = var11;
  848.                         this.fCurrentIndex = var13;
  849.                         super.fCurrentOffset = var15;
  850.                         this.fMostRecentData = var11.toByteArray();
  851.                         this.fMostRecentByte = 93;
  852.                         if (this.fSendCharDataAsCharArray) {
  853.                            this.appendCharData(93);
  854.                         }
  855.                      } else {
  856.                         if (this.fMostRecentData[this.fCurrentIndex + 1] == 62) {
  857.                            ++this.fCurrentIndex;
  858.                            ++super.fCurrentOffset;
  859.                            break label343;
  860.                         }
  861.  
  862.                         if (this.fSendCharDataAsCharArray) {
  863.                            this.appendCharData(93);
  864.                         }
  865.                      }
  866.                      break;
  867.                   case 4:
  868.                      return 4;
  869.                   case 5:
  870.                      do {
  871.                         if (this.fSendCharDataAsCharArray) {
  872.                            this.appendCharData(var3);
  873.                         }
  874.  
  875.                         if (var3 == 10) {
  876.                            ++super.fLinefeedCounter;
  877.                            super.fCharacterCounter = 1;
  878.                         } else {
  879.                            ++super.fCharacterCounter;
  880.                         }
  881.  
  882.                         ++super.fCurrentOffset;
  883.                         if (++this.fCurrentIndex == 16384) {
  884.                            var3 = this.slowLoadNextByte();
  885.                         } else {
  886.                            var3 = this.fMostRecentByte = this.fMostRecentData[this.fCurrentIndex] & 255;
  887.                         }
  888.                      } while(var3 == 32 || var3 == 9 || var3 == 10);
  889.  
  890.                      if ((var3 & 128) == 0) {
  891.                         switch (XMLReader.fgAsciiCharData[var3]) {
  892.                            case 0:
  893.                               ++super.fCharacterCounter;
  894.                               ++super.fCurrentOffset;
  895.                               if (++this.fCurrentIndex == 16384) {
  896.                                  this.slowLoadNextByte();
  897.                               } else {
  898.                                  this.fMostRecentByte = this.fMostRecentData[this.fCurrentIndex] & 255;
  899.                               }
  900.  
  901.                               if (this.fSendCharDataAsCharArray) {
  902.                                  this.appendCharData(var3);
  903.                               }
  904.                               break;
  905.                            case 1:
  906.                               if (!var1.inCDSect) {
  907.                                  if (this.fDocumentHandler != null) {
  908.                                     this.callWSCharDataHandler(var2, super.fCurrentOffset, false);
  909.                                  }
  910.  
  911.                                  ++super.fCharacterCounter;
  912.                                  this.loadNextByte();
  913.                                  return 25;
  914.                               }
  915.  
  916.                               ++super.fCharacterCounter;
  917.                               ++super.fCurrentOffset;
  918.                               if (++this.fCurrentIndex == 16384) {
  919.                                  this.slowLoadNextByte();
  920.                               } else {
  921.                                  this.fMostRecentByte = this.fMostRecentData[this.fCurrentIndex] & 255;
  922.                               }
  923.  
  924.                               if (this.fSendCharDataAsCharArray) {
  925.                                  this.appendCharData(var3);
  926.                               }
  927.                               break;
  928.                            case 2:
  929.                               if (!var1.inCDSect) {
  930.                                  if (this.fDocumentHandler != null) {
  931.                                     this.callWSCharDataHandler(var2, super.fCurrentOffset, false);
  932.                                  }
  933.  
  934.                                  ++super.fCharacterCounter;
  935.                                  this.loadNextByte();
  936.                                  return 26;
  937.                               }
  938.  
  939.                               ++super.fCharacterCounter;
  940.                               ++super.fCurrentOffset;
  941.                               if (++this.fCurrentIndex == 16384) {
  942.                                  this.slowLoadNextByte();
  943.                               } else {
  944.                                  this.fMostRecentByte = this.fMostRecentData[this.fCurrentIndex] & 255;
  945.                               }
  946.  
  947.                               if (this.fSendCharDataAsCharArray) {
  948.                                  this.appendCharData(var3);
  949.                               }
  950.                               break;
  951.                            case 3:
  952.                               var4 = super.fCurrentOffset;
  953.                               var3 = this.loadNextByte();
  954.                               if (var3 != 93) {
  955.                                  ++super.fCharacterCounter;
  956.                                  if (this.fSendCharDataAsCharArray) {
  957.                                     this.appendCharData(93);
  958.                                  }
  959.                               } else if (this.fCurrentIndex + 1 == 16384) {
  960.                                  UTF8DataChunk var5 = this.fCurrentChunk;
  961.                                  int var6 = this.fCurrentIndex;
  962.                                  int var7 = super.fCurrentOffset;
  963.                                  if (this.loadNextByte() == 62) {
  964.                                     break label326;
  965.                                  }
  966.  
  967.                                  this.fCurrentChunk = var5;
  968.                                  this.fCurrentIndex = var6;
  969.                                  super.fCurrentOffset = var7;
  970.                                  this.fMostRecentData = var5.toByteArray();
  971.                                  this.fMostRecentByte = 93;
  972.                                  ++super.fCharacterCounter;
  973.                                  if (this.fSendCharDataAsCharArray) {
  974.                                     this.appendCharData(93);
  975.                                  }
  976.                               } else {
  977.                                  if (this.fMostRecentData[this.fCurrentIndex + 1] == 62) {
  978.                                     ++this.fCurrentIndex;
  979.                                     ++super.fCurrentOffset;
  980.                                     break label326;
  981.                                  }
  982.  
  983.                                  ++super.fCharacterCounter;
  984.                                  if (this.fSendCharDataAsCharArray) {
  985.                                     this.appendCharData(93);
  986.                                  }
  987.                               }
  988.                               break;
  989.                            case 4:
  990.                               if (this.fDocumentHandler != null) {
  991.                                  this.callWSCharDataHandler(var2, super.fCurrentOffset, var1.inCDSect);
  992.                               }
  993.  
  994.                               return 28;
  995.                         }
  996.                      } else if (this.fSendCharDataAsCharArray) {
  997.                         if (!this.copyMultiByteCharData(var3)) {
  998.                            this.callWSCharDataHandler(var2, super.fCurrentOffset, var1.inCDSect);
  999.                            return 28;
  1000.                         }
  1001.                      } else if (!this.skipMultiByteCharData(var3)) {
  1002.                         if (this.fDocumentHandler != null) {
  1003.                            this.callWSCharDataHandler(var2, super.fCurrentOffset, var1.inCDSect);
  1004.                         }
  1005.  
  1006.                         return 28;
  1007.                      }
  1008.                }
  1009.             }
  1010.  
  1011.             if (this.fSendCharDataAsCharArray) {
  1012.                var3 = this.copyAsciiCharData();
  1013.             } else {
  1014.                var3 = this.skipAsciiCharData();
  1015.             }
  1016.  
  1017.             label275:
  1018.             while(true) {
  1019.                for(; (var3 & 128) != 0; var3 = this.fMostRecentByte) {
  1020.                   if (this.fSendCharDataAsCharArray) {
  1021.                      if (!this.copyMultiByteCharData(var3)) {
  1022.                         this.callCharDataHandler(var2, super.fCurrentOffset, var1.inCDSect);
  1023.                         return 12;
  1024.                      }
  1025.                   } else if (!this.skipMultiByteCharData(var3)) {
  1026.                      if (this.fDocumentHandler != null) {
  1027.                         this.callCharDataHandler(var2, super.fCurrentOffset, var1.inCDSect);
  1028.                      }
  1029.  
  1030.                      return 12;
  1031.                   }
  1032.                }
  1033.  
  1034.                switch (XMLReader.fgAsciiCharData[var3]) {
  1035.                   case 0:
  1036.                      ++super.fCharacterCounter;
  1037.                      if (this.fSendCharDataAsCharArray) {
  1038.                         this.appendCharData(var3);
  1039.                      }
  1040.  
  1041.                      var3 = this.loadNextByte();
  1042.                      break;
  1043.                   case 1:
  1044.                      if (!var1.inCDSect) {
  1045.                         if (this.fDocumentHandler != null) {
  1046.                            this.callCharDataHandler(var2, super.fCurrentOffset, false);
  1047.                         }
  1048.  
  1049.                         ++super.fCharacterCounter;
  1050.                         ++super.fCurrentOffset;
  1051.                         if (++this.fCurrentIndex == 16384) {
  1052.                            this.slowLoadNextByte();
  1053.                         } else {
  1054.                            this.fMostRecentByte = this.fMostRecentData[this.fCurrentIndex] & 255;
  1055.                         }
  1056.  
  1057.                         return 9;
  1058.                      }
  1059.  
  1060.                      ++super.fCharacterCounter;
  1061.                      if (this.fSendCharDataAsCharArray) {
  1062.                         this.appendCharData(var3);
  1063.                      }
  1064.  
  1065.                      var3 = this.loadNextByte();
  1066.                      break;
  1067.                   case 2:
  1068.                      if (!var1.inCDSect) {
  1069.                         if (this.fDocumentHandler != null) {
  1070.                            this.callCharDataHandler(var2, super.fCurrentOffset, false);
  1071.                         }
  1072.  
  1073.                         ++super.fCharacterCounter;
  1074.                         ++super.fCurrentOffset;
  1075.                         if (++this.fCurrentIndex == 16384) {
  1076.                            this.slowLoadNextByte();
  1077.                         } else {
  1078.                            this.fMostRecentByte = this.fMostRecentData[this.fCurrentIndex] & 255;
  1079.                         }
  1080.  
  1081.                         return 10;
  1082.                      }
  1083.  
  1084.                      ++super.fCharacterCounter;
  1085.                      if (this.fSendCharDataAsCharArray) {
  1086.                         this.appendCharData(var3);
  1087.                      }
  1088.  
  1089.                      var3 = this.loadNextByte();
  1090.                      break;
  1091.                   case 3:
  1092.                      var4 = super.fCurrentOffset;
  1093.                      var3 = this.loadNextByte();
  1094.                      if (var3 == 93) {
  1095.                         if (this.fCurrentIndex + 1 == 16384) {
  1096.                            UTF8DataChunk var14 = this.fCurrentChunk;
  1097.                            int var16 = this.fCurrentIndex;
  1098.                            int var17 = super.fCurrentOffset;
  1099.                            if (this.loadNextByte() == 62) {
  1100.                               break label275;
  1101.                            }
  1102.  
  1103.                            this.fCurrentChunk = var14;
  1104.                            this.fCurrentIndex = var16;
  1105.                            super.fCurrentOffset = var17;
  1106.                            this.fMostRecentData = var14.toByteArray();
  1107.                            this.fMostRecentByte = 93;
  1108.                            ++super.fCharacterCounter;
  1109.                            if (this.fSendCharDataAsCharArray) {
  1110.                               this.appendCharData(93);
  1111.                            }
  1112.                         } else {
  1113.                            if (this.fMostRecentData[this.fCurrentIndex + 1] == 62) {
  1114.                               ++this.fCurrentIndex;
  1115.                               ++super.fCurrentOffset;
  1116.                               break label275;
  1117.                            }
  1118.  
  1119.                            ++super.fCharacterCounter;
  1120.                            if (this.fSendCharDataAsCharArray) {
  1121.                               this.appendCharData(93);
  1122.                            }
  1123.                         }
  1124.                      } else {
  1125.                         ++super.fCharacterCounter;
  1126.                         if (this.fSendCharDataAsCharArray) {
  1127.                            this.appendCharData(93);
  1128.                         }
  1129.                      }
  1130.                      break;
  1131.                   case 4:
  1132.                      if (var3 != 10) {
  1133.                         if (this.fDocumentHandler != null) {
  1134.                            this.callCharDataHandler(var2, super.fCurrentOffset, var1.inCDSect);
  1135.                         }
  1136.  
  1137.                         return 12;
  1138.                      }
  1139.  
  1140.                      ++super.fLinefeedCounter;
  1141.                      super.fCharacterCounter = 1;
  1142.                      var3 = this.loadNextByte();
  1143.                }
  1144.             }
  1145.  
  1146.             this.loadNextByte();
  1147.             if (this.fDocumentHandler != null) {
  1148.                this.callCharDataHandler(var2, var4, var1.inCDSect);
  1149.             }
  1150.  
  1151.             super.fCharacterCounter += 3;
  1152.             if (var1.inCDSect) {
  1153.                var1.inCDSect = false;
  1154.                return this.scanContent(var1);
  1155.             }
  1156.  
  1157.             return 11;
  1158.          }
  1159.  
  1160.          this.loadNextByte();
  1161.          super.fCharacterCounter += 2;
  1162.          if (var1.inCDSect) {
  1163.             var1.inCDSect = false;
  1164.             return this.scanContent(var1);
  1165.          }
  1166.  
  1167.          return 3;
  1168.       }
  1169.  
  1170.       this.loadNextByte();
  1171.       if (this.fDocumentHandler != null) {
  1172.          this.callWSCharDataHandler(var2, var4, var1.inCDSect);
  1173.       }
  1174.  
  1175.       super.fCharacterCounter += 3;
  1176.       if (var1.inCDSect) {
  1177.          var1.inCDSect = false;
  1178.          return this.scanContent(var1);
  1179.       } else {
  1180.          return 27;
  1181.       }
  1182.    }
  1183.  
  1184.    protected boolean copyMultiByteCharData(int var1) throws Exception {
  1185.       UTF8DataChunk var2 = this.fCurrentChunk;
  1186.       int var3 = super.fCurrentOffset;
  1187.       int var4 = this.fCurrentIndex;
  1188.       int var5 = this.loadNextByte();
  1189.       if ((224 & var1) == 192) {
  1190.          int var9 = ((31 & var1) << 6) + (63 & var5);
  1191.          this.appendCharData(var9);
  1192.          return true;
  1193.       } else {
  1194.          int var6 = this.loadNextByte();
  1195.          if ((240 & var1) == 224) {
  1196.             if ((var1 != 237 || var5 < 160) && (var1 != 239 || var5 != 191 || var6 < 190)) {
  1197.                int var10 = ((15 & var1) << 12) + ((63 & var5) << 6) + (63 & var6);
  1198.                this.appendCharData(var10);
  1199.                return true;
  1200.             } else {
  1201.                this.fCurrentChunk = var2;
  1202.                this.fCurrentIndex = var4;
  1203.                super.fCurrentOffset = var3;
  1204.                this.fMostRecentData = var2.toByteArray();
  1205.                this.fMostRecentByte = var1;
  1206.                return false;
  1207.             }
  1208.          } else {
  1209.             int var7 = this.loadNextByte();
  1210.             if (var1 <= 244 && (var1 != 244 || var5 < 144)) {
  1211.                int var8 = ((15 & var1) << 18) + ((63 & var5) << 12) + ((63 & var6) << 6) + (63 & var7);
  1212.                if (var8 < 65536) {
  1213.                   this.appendCharData(var8);
  1214.                } else {
  1215.                   this.appendCharData((var8 - 65536 >> 10) + '\ud800');
  1216.                   this.appendCharData((var8 - 65536 & 1023) + '\udc00');
  1217.                }
  1218.  
  1219.                return true;
  1220.             } else {
  1221.                this.fCurrentChunk = var2;
  1222.                this.fCurrentIndex = var4;
  1223.                super.fCurrentOffset = var3;
  1224.                this.fMostRecentData = var2.toByteArray();
  1225.                this.fMostRecentByte = var1;
  1226.                return false;
  1227.             }
  1228.          }
  1229.       }
  1230.    }
  1231.  
  1232.    protected boolean skipMultiByteCharData(int var1) throws Exception {
  1233.       UTF8DataChunk var2 = this.fCurrentChunk;
  1234.       int var3 = super.fCurrentOffset;
  1235.       int var4 = this.fCurrentIndex;
  1236.       int var5 = this.loadNextByte();
  1237.       if ((224 & var1) == 192) {
  1238.          return true;
  1239.       } else {
  1240.          int var6 = this.loadNextByte();
  1241.          if ((240 & var1) == 224) {
  1242.             if ((var1 != 237 || var5 < 160) && (var1 != 239 || var5 != 191 || var6 < 190)) {
  1243.                return true;
  1244.             } else {
  1245.                this.fCurrentChunk = var2;
  1246.                this.fCurrentIndex = var4;
  1247.                super.fCurrentOffset = var3;
  1248.                this.fMostRecentData = var2.toByteArray();
  1249.                this.fMostRecentByte = var1;
  1250.                return false;
  1251.             }
  1252.          } else {
  1253.             this.loadNextByte();
  1254.             if (var1 <= 244 && (var1 != 244 || var5 < 144)) {
  1255.                return true;
  1256.             } else {
  1257.                this.fCurrentChunk = var2;
  1258.                this.fCurrentIndex = var4;
  1259.                super.fCurrentOffset = var3;
  1260.                this.fMostRecentData = var2.toByteArray();
  1261.                this.fMostRecentByte = var1;
  1262.                return false;
  1263.             }
  1264.          }
  1265.       }
  1266.    }
  1267.  
  1268.    protected int copyAsciiCharData() throws Exception {
  1269.       int var1 = this.fCharDataLength;
  1270.       int var2 = this.fCurrentIndex;
  1271.       int var3 = super.fCurrentOffset - var2;
  1272.  
  1273.       while(true) {
  1274.          byte[] var4 = this.fMostRecentData;
  1275.  
  1276.          while(var2 < 16384) {
  1277.             int var5 = 16384;
  1278.             int var6 = this.fCharacters.length - 2 - var1;
  1279.             int var7 = 16384 - var2;
  1280.             if (var6 < var7) {
  1281.                if (var6 < 64) {
  1282.                   char[] var8 = new char[this.fCharacters.length * 2];
  1283.                   System.arraycopy(this.fCharacters, 0, var8, 0, this.fCharacters.length);
  1284.                   this.fCharacters = var8;
  1285.                   var6 = this.fCharacters.length - 2 - var1;
  1286.                   if (var6 < var7) {
  1287.                      var5 = var2 + var6;
  1288.                   }
  1289.                } else {
  1290.                   var5 = var2 + var6;
  1291.                }
  1292.             }
  1293.  
  1294.             while(var2 < var5) {
  1295.                int var10 = var4[var2] & 255;
  1296.                if ((var10 & 128) != 0) {
  1297.                   super.fCurrentOffset = var3 + var2;
  1298.                   this.fCurrentIndex = var2;
  1299.                   this.fMostRecentByte = var10;
  1300.                   this.fCharDataLength = var1;
  1301.                   return var10;
  1302.                }
  1303.  
  1304.                if (XMLReader.fgAsciiCharData[var10] != 0) {
  1305.                   if (var10 != 10) {
  1306.                      super.fCurrentOffset = var3 + var2;
  1307.                      this.fCurrentIndex = var2;
  1308.                      this.fMostRecentByte = var10;
  1309.                      this.fCharDataLength = var1;
  1310.                      return var10;
  1311.                   }
  1312.  
  1313.                   ++super.fLinefeedCounter;
  1314.                   super.fCharacterCounter = 1;
  1315.                } else {
  1316.                   ++super.fCharacterCounter;
  1317.                }
  1318.  
  1319.                this.fCharacters[var1++] = (char)var10;
  1320.                ++var2;
  1321.             }
  1322.          }
  1323.  
  1324.          var3 += var2;
  1325.          this.fCurrentChunk = new UTF8DataChunk(this, this.fStringPool, this.fCurrentChunk);
  1326.          this.fillCurrentChunk();
  1327.          var2 = 0;
  1328.       }
  1329.    }
  1330.  
  1331.    protected int skipAsciiCharData() throws Exception {
  1332.       int var1 = this.fCurrentIndex;
  1333.       int var2 = super.fCurrentOffset - var1;
  1334.  
  1335.       while(true) {
  1336.          for(byte[] var3 = this.fMostRecentData; var1 < 16384; ++var1) {
  1337.             int var4 = var3[var1] & 255;
  1338.             if ((var4 & 128) != 0) {
  1339.                super.fCurrentOffset = var2 + var1;
  1340.                this.fCurrentIndex = var1;
  1341.                this.fMostRecentByte = var4;
  1342.                return var4;
  1343.             }
  1344.  
  1345.             if (XMLReader.fgAsciiCharData[var4] != 0) {
  1346.                if (var4 != 10) {
  1347.                   super.fCurrentOffset = var2 + var1;
  1348.                   this.fCurrentIndex = var1;
  1349.                   this.fMostRecentByte = var4;
  1350.                   return var4;
  1351.                }
  1352.  
  1353.                ++super.fLinefeedCounter;
  1354.                super.fCharacterCounter = 1;
  1355.             } else {
  1356.                ++super.fCharacterCounter;
  1357.             }
  1358.          }
  1359.  
  1360.          var2 += var1;
  1361.          this.fCurrentChunk = new UTF8DataChunk(this, this.fStringPool, this.fCurrentChunk);
  1362.          this.fillCurrentChunk();
  1363.          var1 = 0;
  1364.       }
  1365.    }
  1366.  
  1367.    protected void appendCharData(int var1) {
  1368.       if (this.fCharacters.length == this.fCharDataLength) {
  1369.          char[] var2 = new char[this.fCharacters.length * 2];
  1370.          System.arraycopy(this.fCharacters, 0, var2, 0, this.fCharacters.length);
  1371.          this.fCharacters = var2;
  1372.       }
  1373.  
  1374.       this.fCharacters[this.fCharDataLength++] = (char)var1;
  1375.    }
  1376.  
  1377.    public void callCharDataHandler(int var1, int var2, boolean var3) throws Exception {
  1378.       if (!this.fSendCharDataAsCharArray) {
  1379.          int var4 = var2 - var1;
  1380.          var4 = var4 == 0 ? 0 : this.fCurrentChunk.addString(var1, var4);
  1381.          this.fDocumentHandler.characters(var4, var3);
  1382.       } else {
  1383.          this.fDocumentHandler.characters(this.fCharacters, 0, this.fCharDataLength, var3);
  1384.       }
  1385.    }
  1386.  
  1387.    public void callWSCharDataHandler(int var1, int var2, boolean var3) throws Exception {
  1388.       int var4 = super.fParserState.getScanner().getCurrentContentSpecType();
  1389.       if (var4 != 4) {
  1390.          this.callCharDataHandler(var1, var2, var3);
  1391.       } else if (!this.fSendCharDataAsCharArray) {
  1392.          int var5 = var2 - var1;
  1393.          var5 = var5 == 0 ? 0 : this.fCurrentChunk.addString(var1, var5);
  1394.          this.fDocumentHandler.ignorableWhitespace(var5, var3);
  1395.       } else {
  1396.          this.fDocumentHandler.ignorableWhitespace(this.fCharacters, 0, this.fCharDataLength, var3);
  1397.       }
  1398.    }
  1399.  
  1400.    protected int fillCurrentChunk() throws Exception {
  1401.       this.fOutputOffset = 0;
  1402.       if (this.fCheckOverflow) {
  1403.          if (this.fOverflowEnd < 16384) {
  1404.             if (this.fOverflowEnd > 0) {
  1405.                this.fMostRecentData = new byte[1 + this.fOverflowEnd - this.fOverflowOffset];
  1406.                this.copyNormalize(this.fOverflow, this.fOverflowOffset, this.fMostRecentData, this.fOutputOffset);
  1407.             } else {
  1408.                this.fMostRecentData = new byte[1];
  1409.             }
  1410.  
  1411.             this.fMostRecentData[this.fOutputOffset] = 0;
  1412.             this.fOverflow = null;
  1413.             this.fLength += this.fOutputOffset;
  1414.             this.fCurrentIndex = 0;
  1415.             this.fCurrentChunk.setByteArray(this.fMostRecentData);
  1416.             return this.fMostRecentByte = this.fMostRecentData[0];
  1417.          }
  1418.  
  1419.          this.fMostRecentData = new byte[16384];
  1420.          this.copyNormalize(this.fOverflow, this.fOverflowOffset, this.fMostRecentData, this.fOutputOffset);
  1421.          this.fCheckOverflow = false;
  1422.       } else {
  1423.          if (this.fOverflow == null) {
  1424.             this.fOverflow = new byte[16384];
  1425.          }
  1426.  
  1427.          this.fMostRecentData = null;
  1428.       }
  1429.  
  1430.       while(true) {
  1431.          this.fOverflowOffset = 0;
  1432.          this.fOverflowEnd = 0;
  1433.          int var1 = 16384;
  1434.          int var2 = 0;
  1435.  
  1436.          do {
  1437.             var2 = this.fInputStream.read(this.fOverflow, this.fOverflowEnd, var1);
  1438.             if (var2 == -1) {
  1439.                this.fInputStream.close();
  1440.                this.fInputStream = null;
  1441.                if (this.fMostRecentData == null) {
  1442.                   this.fMostRecentData = new byte[1 + this.fOverflowEnd];
  1443.                   this.copyNormalize(this.fOverflow, this.fOverflowOffset, this.fMostRecentData, this.fOutputOffset);
  1444.                   this.fOverflow = null;
  1445.                   this.fMostRecentData[this.fOutputOffset] = 0;
  1446.                } else {
  1447.                   boolean var3 = this.copyNormalize(this.fOverflow, this.fOverflowOffset, this.fMostRecentData, this.fOutputOffset);
  1448.                   if (var3) {
  1449.                      if (this.fOverflowEnd == 16384) {
  1450.                         this.fCheckOverflow = true;
  1451.                         this.fOverflowOffset = 0;
  1452.                         this.fOverflowEnd = 0;
  1453.                      } else {
  1454.                         this.fOverflow = null;
  1455.                         this.fMostRecentData[this.fOutputOffset] = 0;
  1456.                      }
  1457.                   } else {
  1458.                      this.fCheckOverflow = true;
  1459.                   }
  1460.                }
  1461.                break;
  1462.             }
  1463.  
  1464.             if (var2 > 0) {
  1465.                this.fOverflowEnd += var2;
  1466.                var1 -= var2;
  1467.             }
  1468.          } while(var1 > 0);
  1469.  
  1470.          if (var2 == -1) {
  1471.             break;
  1472.          }
  1473.  
  1474.          if (this.fMostRecentData != null) {
  1475.             boolean var5 = this.copyNormalize(this.fOverflow, this.fOverflowOffset, this.fMostRecentData, this.fOutputOffset);
  1476.             if (this.fOutputOffset == 16384) {
  1477.                if (!var5) {
  1478.                   this.fCheckOverflow = true;
  1479.                }
  1480.                break;
  1481.             }
  1482.          } else {
  1483.             this.fMostRecentData = new byte[16384];
  1484.             this.copyNormalize(this.fOverflow, this.fOverflowOffset, this.fMostRecentData, this.fOutputOffset);
  1485.             if (this.fOutputOffset == 16384) {
  1486.                break;
  1487.             }
  1488.          }
  1489.       }
  1490.  
  1491.       this.fLength += this.fOutputOffset;
  1492.       this.fCurrentIndex = 0;
  1493.       this.fCurrentChunk.setByteArray(this.fMostRecentData);
  1494.       return this.fMostRecentByte = this.fMostRecentData[0];
  1495.    }
  1496.  
  1497.    protected boolean copyNormalize(byte[] var1, int var2, byte[] var3, int var4) throws Exception {
  1498.       int var5 = this.fOverflowEnd;
  1499.       int var6 = var3.length;
  1500.       if (var2 == var5) {
  1501.          return true;
  1502.       } else {
  1503.          byte var7 = var1[var2];
  1504.          if (this.fSkipLinefeed) {
  1505.             this.fSkipLinefeed = false;
  1506.             if (var7 == 10) {
  1507.                ++var2;
  1508.                if (var2 == var5) {
  1509.                   this.fOverflowOffset = var2;
  1510.                   this.fOutputOffset = var4;
  1511.                   return true;
  1512.                }
  1513.  
  1514.                var7 = var1[var2];
  1515.             }
  1516.          } else if (this.fPartialMultiByteIn > 0) {
  1517.             if (!this.handlePartialMultiByteChar(var7, var1, var2, var5, var3, var4, var6)) {
  1518.                return this.fPartialMultiByteResult;
  1519.             }
  1520.  
  1521.             var2 = this.fOverflowOffset;
  1522.             var4 = this.fOutputOffset;
  1523.             var7 = var1[var2];
  1524.          }
  1525.  
  1526.          while(var4 < var6) {
  1527.             int var8 = var5 - var2;
  1528.             int var9 = var6 - var4;
  1529.             if (var8 > var9) {
  1530.                var8 = var9;
  1531.             }
  1532.  
  1533.             ++var2;
  1534.  
  1535.             do {
  1536.                for(; var7 == 13 || (var7 & 128) != 0; ++var2) {
  1537.                   if (var7 == 13) {
  1538.                      var3[var4++] = 10;
  1539.                      if (var2 == var5) {
  1540.                         this.fSkipLinefeed = true;
  1541.                         this.fOverflowOffset = var2;
  1542.                         this.fOutputOffset = var4;
  1543.                         return true;
  1544.                      }
  1545.  
  1546.                      var7 = var1[var2];
  1547.                      if (var7 == 10) {
  1548.                         ++var2;
  1549.                         if (var2 == var5) {
  1550.                            this.fOverflowOffset = var2;
  1551.                            this.fOutputOffset = var4;
  1552.                            return true;
  1553.                         }
  1554.  
  1555.                         var7 = var1[var2];
  1556.                      }
  1557.  
  1558.                      if (var4 == var6) {
  1559.                         this.fOverflowOffset = var2;
  1560.                         this.fOutputOffset = var4;
  1561.                         return false;
  1562.                      }
  1563.                   } else {
  1564.                      if (!this.handleMultiByteChar(var7, var1, var2, var5, var3, var4, var6)) {
  1565.                         return this.fPartialMultiByteResult;
  1566.                      }
  1567.  
  1568.                      var2 = this.fOverflowOffset;
  1569.                      var4 = this.fOutputOffset;
  1570.                      var7 = var1[var2];
  1571.                   }
  1572.  
  1573.                   var8 = var5 - var2;
  1574.                   var9 = var6 - var4;
  1575.                   if (var8 > var9) {
  1576.                      var8 = var9;
  1577.                   }
  1578.                }
  1579.  
  1580.                do {
  1581.                   var3[var4++] = var7;
  1582.                   --var8;
  1583.                   if (var8 == 0) {
  1584.                      break;
  1585.                   }
  1586.  
  1587.                   var7 = var1[var2++];
  1588.                } while(var7 != 13 && (var7 & 128) == 0);
  1589.             } while(var8 != 0);
  1590.  
  1591.             if (var2 == var5) {
  1592.                break;
  1593.             }
  1594.          }
  1595.  
  1596.          boolean var10 = var2 == var5;
  1597.          this.fOverflowOffset = var2;
  1598.          this.fOutputOffset = var4;
  1599.          return var10;
  1600.       }
  1601.    }
  1602.  
  1603.    protected boolean exitNormalize(int var1, int var2, boolean var3) {
  1604.       this.fOverflowOffset = var1;
  1605.       this.fOutputOffset = var2;
  1606.       return var3;
  1607.    }
  1608.  
  1609.    protected void savePartialMultiByte(int var1, int var2, byte var3, byte var4, byte var5, byte var6) {
  1610.       this.fPartialMultiByteIn = var1;
  1611.       this.fPartialMultiByteOut = var2;
  1612.       --var1;
  1613.       this.fPartialMultiByteChar[var1] = var3;
  1614.       --var1;
  1615.       this.fPartialMultiByteChar[var1] = var4;
  1616.       --var1;
  1617.       this.fPartialMultiByteChar[var1] = var5;
  1618.       --var1;
  1619.       this.fPartialMultiByteChar[var1] = var6;
  1620.    }
  1621.  
  1622.    protected void savePartialMultiByte(int var1, int var2, byte var3, byte var4, byte var5) {
  1623.       this.fPartialMultiByteIn = var1;
  1624.       this.fPartialMultiByteOut = var2;
  1625.       --var1;
  1626.       this.fPartialMultiByteChar[var1] = var3;
  1627.       --var1;
  1628.       this.fPartialMultiByteChar[var1] = var4;
  1629.       --var1;
  1630.       this.fPartialMultiByteChar[var1] = var5;
  1631.    }
  1632.  
  1633.    protected void savePartialMultiByte(int var1, int var2, byte var3, byte var4) {
  1634.       this.fPartialMultiByteIn = var1;
  1635.       this.fPartialMultiByteOut = var2;
  1636.       --var1;
  1637.       this.fPartialMultiByteChar[var1] = var3;
  1638.       --var1;
  1639.       this.fPartialMultiByteChar[var1] = var4;
  1640.    }
  1641.  
  1642.    protected void savePartialMultiByte(int var1, int var2, byte var3) {
  1643.       this.fPartialMultiByteIn = var1;
  1644.       this.fPartialMultiByteOut = var2;
  1645.       --var1;
  1646.       this.fPartialMultiByteChar[var1] = var3;
  1647.    }
  1648.  
  1649.    protected boolean handleMultiByteChar(byte var1, byte[] var2, int var3, int var4, byte[] var5, int var6, int var7) throws Exception {
  1650.       if (var3 == var4) {
  1651.          int var20 = 1;
  1652.          this.fPartialMultiByteIn = var20;
  1653.          this.fPartialMultiByteOut = 0;
  1654.          --var20;
  1655.          this.fPartialMultiByteChar[var20] = var1;
  1656.          this.fOverflowOffset = var3;
  1657.          this.fOutputOffset = var6;
  1658.          this.fPartialMultiByteResult = true;
  1659.          return false;
  1660.       } else {
  1661.          byte var8 = var2[var3++];
  1662.          if ((var8 & 192) != 128) {
  1663.             this.fErrorHandler.error2(57, this.fStringPool.addString(Integer.toHexString(var1)), this.fStringPool.addString(Integer.toHexString(var8)));
  1664.          }
  1665.  
  1666.          if ((var1 & 224) == 192) {
  1667.             var5[var6++] = var1;
  1668.             if (var6 == var7) {
  1669.                this.savePartialMultiByte(2, 1, var8, var1);
  1670.                boolean var23 = var3 == var4;
  1671.                this.fOverflowOffset = var3;
  1672.                this.fOutputOffset = var6;
  1673.                this.fPartialMultiByteResult = var23;
  1674.                return false;
  1675.             }
  1676.  
  1677.             var5[var6++] = var8;
  1678.             if (var3 == var4 || var6 == var7) {
  1679.                boolean var22 = var3 == var4;
  1680.                this.fOverflowOffset = var3;
  1681.                this.fOutputOffset = var6;
  1682.                this.fPartialMultiByteResult = var22;
  1683.                return false;
  1684.             }
  1685.          } else {
  1686.             if (var3 == var4) {
  1687.                this.savePartialMultiByte(2, 0, var8, var1);
  1688.                this.fOverflowOffset = var3;
  1689.                this.fOutputOffset = var6;
  1690.                this.fPartialMultiByteResult = true;
  1691.                return false;
  1692.             }
  1693.  
  1694.             byte var9 = var2[var3++];
  1695.             if ((var9 & 192) != 128) {
  1696.                this.fErrorHandler.error3(58, this.fStringPool.addString(Integer.toHexString(var1)), this.fStringPool.addString(Integer.toHexString(var8)), this.fStringPool.addString(Integer.toHexString(var9)));
  1697.             }
  1698.  
  1699.             if ((var1 & 240) == 224) {
  1700.                var5[var6++] = var1;
  1701.                if (var6 == var7) {
  1702.                   this.savePartialMultiByte(3, 1, var9, var8, var1);
  1703.                   boolean var26 = var3 == var4;
  1704.                   this.fOverflowOffset = var3;
  1705.                   this.fOutputOffset = var6;
  1706.                   this.fPartialMultiByteResult = var26;
  1707.                   return false;
  1708.                }
  1709.  
  1710.                var5[var6++] = var8;
  1711.                if (var6 == var7) {
  1712.                   this.savePartialMultiByte(3, 2, var9, var8, var1);
  1713.                   boolean var25 = var3 == var4;
  1714.                   this.fOverflowOffset = var3;
  1715.                   this.fOutputOffset = var6;
  1716.                   this.fPartialMultiByteResult = var25;
  1717.                   return false;
  1718.                }
  1719.  
  1720.                var5[var6++] = var9;
  1721.                if (var3 == var4 || var6 == var7) {
  1722.                   boolean var24 = var3 == var4;
  1723.                   this.fOverflowOffset = var3;
  1724.                   this.fOutputOffset = var6;
  1725.                   this.fPartialMultiByteResult = var24;
  1726.                   return false;
  1727.                }
  1728.             } else {
  1729.                if ((var1 & 248) != 240) {
  1730.                   this.fErrorHandler.error1(56, this.fStringPool.addString(Integer.toHexString(var1)));
  1731.                }
  1732.  
  1733.                if (var3 == var4) {
  1734.                   this.savePartialMultiByte(3, 0, var9, var8, var1);
  1735.                   this.fOverflowOffset = var3;
  1736.                   this.fOutputOffset = var6;
  1737.                   this.fPartialMultiByteResult = true;
  1738.                   return false;
  1739.                }
  1740.  
  1741.                byte var10 = var2[var3++];
  1742.                if ((var10 & 192) != 128) {
  1743.                   this.fErrorHandler.error4(59, this.fStringPool.addString(Integer.toHexString(var1)), this.fStringPool.addString(Integer.toHexString(var8)), this.fStringPool.addString(Integer.toHexString(var9)), this.fStringPool.addString(Integer.toHexString(var10)));
  1744.                }
  1745.  
  1746.                var5[var6++] = var1;
  1747.                if (var6 == var7) {
  1748.                   this.savePartialMultiByte(4, 1, var10, var9, var8, var1);
  1749.                   boolean var29 = var3 == var4;
  1750.                   this.fOverflowOffset = var3;
  1751.                   this.fOutputOffset = var6;
  1752.                   this.fPartialMultiByteResult = var29;
  1753.                   return false;
  1754.                }
  1755.  
  1756.                var5[var6++] = var8;
  1757.                if (var6 == var7) {
  1758.                   this.savePartialMultiByte(4, 2, var10, var9, var8, var1);
  1759.                   boolean var28 = var3 == var4;
  1760.                   this.fOverflowOffset = var3;
  1761.                   this.fOutputOffset = var6;
  1762.                   this.fPartialMultiByteResult = var28;
  1763.                   return false;
  1764.                }
  1765.  
  1766.                var5[var6++] = var9;
  1767.                if (var6 == var7) {
  1768.                   this.savePartialMultiByte(4, 3, var10, var9, var8, var1);
  1769.                   boolean var27 = var3 == var4;
  1770.                   this.fOverflowOffset = var3;
  1771.                   this.fOutputOffset = var6;
  1772.                   this.fPartialMultiByteResult = var27;
  1773.                   return false;
  1774.                }
  1775.  
  1776.                var5[var6++] = var10;
  1777.                if (var3 == var4 || var6 == var7) {
  1778.                   boolean var11 = var3 == var4;
  1779.                   this.fOverflowOffset = var3;
  1780.                   this.fOutputOffset = var6;
  1781.                   this.fPartialMultiByteResult = var11;
  1782.                   return false;
  1783.                }
  1784.             }
  1785.          }
  1786.  
  1787.          this.fOverflowOffset = var3;
  1788.          this.fOutputOffset = var6;
  1789.          return true;
  1790.       }
  1791.    }
  1792.  
  1793.    protected boolean handlePartialMultiByteChar(byte var1, byte[] var2, int var3, int var4, byte[] var5, int var6, int var7) throws Exception {
  1794.       if (var6 == var7) {
  1795.          boolean var16 = var3 == var4;
  1796.          this.fOverflowOffset = var3;
  1797.          this.fOutputOffset = var6;
  1798.          this.fPartialMultiByteResult = var16;
  1799.          return false;
  1800.       } else {
  1801.          int var8 = this.fPartialMultiByteIn;
  1802.          int var9 = this.fPartialMultiByteOut;
  1803.          this.fPartialMultiByteIn = 0;
  1804.          this.fPartialMultiByteOut = 0;
  1805.          byte var10 = 0;
  1806.          byte var11 = 0;
  1807.          byte var12 = 0;
  1808.          boolean var13 = false;
  1809.          switch (var8) {
  1810.             case 1:
  1811.                var10 = var1;
  1812.                break;
  1813.             case 2:
  1814.                var11 = var1;
  1815.                break;
  1816.             case 3:
  1817.                var12 = var1;
  1818.             case 4:
  1819.          }
  1820.  
  1821.          int var14 = var8;
  1822.          switch (var8) {
  1823.             case 4:
  1824.                var14 = var8 - 1;
  1825.                var12 = this.fPartialMultiByteChar[var14];
  1826.             case 3:
  1827.                --var14;
  1828.                var11 = this.fPartialMultiByteChar[var14];
  1829.             case 2:
  1830.                --var14;
  1831.                var10 = this.fPartialMultiByteChar[var14];
  1832.             case 1:
  1833.                --var14;
  1834.                var1 = this.fPartialMultiByteChar[var14];
  1835.          }
  1836.  
  1837.          label114:
  1838.          switch (var8) {
  1839.             case 1:
  1840.                if ((var10 & 192) != 128) {
  1841.                   this.fErrorHandler.error2(57, this.fStringPool.addString(Integer.toHexString(var1)), this.fStringPool.addString(Integer.toHexString(var10)));
  1842.                }
  1843.             case 2:
  1844.                if ((var1 & 224) == 192) {
  1845.                   switch (var9) {
  1846.                      case 0:
  1847.                         var5[var6++] = var1;
  1848.                         if (var6 == var7) {
  1849.                            int var19 = 2;
  1850.                            this.fPartialMultiByteIn = var19;
  1851.                            this.fPartialMultiByteOut = 1;
  1852.                            --var19;
  1853.                            this.fPartialMultiByteChar[var19] = var10;
  1854.                            this.fOverflowOffset = var3;
  1855.                            this.fOutputOffset = var6;
  1856.                            this.fPartialMultiByteResult = false;
  1857.                            return false;
  1858.                         }
  1859.                      case 1:
  1860.                         var5[var6++] = var10;
  1861.                         if (var6 == var7) {
  1862.                            this.fOverflowOffset = var3;
  1863.                            this.fOutputOffset = var6;
  1864.                            this.fPartialMultiByteResult = false;
  1865.                            return false;
  1866.                         }
  1867.                      default:
  1868.                         if (var8 < 2) {
  1869.                            ++var3;
  1870.                            if (var3 == var4) {
  1871.                               this.fOverflowOffset = var3;
  1872.                               this.fOutputOffset = var6;
  1873.                               this.fPartialMultiByteResult = true;
  1874.                               return false;
  1875.                            }
  1876.                         }
  1877.                         break label114;
  1878.                   }
  1879.                } else {
  1880.                   if (var8 < 2) {
  1881.                      ++var3;
  1882.                      if (var3 == var4) {
  1883.                         int var15 = 2;
  1884.                         this.fPartialMultiByteIn = var15;
  1885.                         this.fPartialMultiByteOut = 0;
  1886.                         --var15;
  1887.                         this.fPartialMultiByteChar[var15] = var10;
  1888.                         this.fOverflowOffset = var3;
  1889.                         this.fOutputOffset = var6;
  1890.                         this.fPartialMultiByteResult = true;
  1891.                         return false;
  1892.                      }
  1893.  
  1894.                      var11 = var2[var3];
  1895.                   }
  1896.  
  1897.                   if ((var11 & 192) != 128) {
  1898.                      this.fErrorHandler.error3(58, this.fStringPool.addString(Integer.toHexString(var1)), this.fStringPool.addString(Integer.toHexString(var10)), this.fStringPool.addString(Integer.toHexString(var11)));
  1899.                   }
  1900.                }
  1901.             case 3:
  1902.                if ((var1 & 240) == 224) {
  1903.                   switch (var9) {
  1904.                      case 0:
  1905.                         var5[var6++] = var1;
  1906.                         if (var6 == var7) {
  1907.                            this.savePartialMultiByte(3, 1, var11, var10);
  1908.                            this.fOverflowOffset = var3;
  1909.                            this.fOutputOffset = var6;
  1910.                            this.fPartialMultiByteResult = false;
  1911.                            return false;
  1912.                         }
  1913.                      case 1:
  1914.                         var5[var6++] = var10;
  1915.                         if (var6 == var7) {
  1916.                            this.savePartialMultiByte(3, 2, var11, var10);
  1917.                            this.fOverflowOffset = var3;
  1918.                            this.fOutputOffset = var6;
  1919.                            this.fPartialMultiByteResult = false;
  1920.                            return false;
  1921.                         }
  1922.                      case 2:
  1923.                         var5[var6++] = var11;
  1924.                         if (var6 == var7) {
  1925.                            this.fOverflowOffset = var3;
  1926.                            this.fOutputOffset = var6;
  1927.                            this.fPartialMultiByteResult = false;
  1928.                            return false;
  1929.                         }
  1930.                      default:
  1931.                         if (var8 < 3) {
  1932.                            ++var3;
  1933.                            if (var3 == var4) {
  1934.                               this.fOverflowOffset = var3;
  1935.                               this.fOutputOffset = var6;
  1936.                               this.fPartialMultiByteResult = true;
  1937.                               return false;
  1938.                            }
  1939.                         }
  1940.                         break label114;
  1941.                   }
  1942.                } else {
  1943.                   if (var8 < 3) {
  1944.                      if ((var1 & 248) != 240) {
  1945.                         this.fErrorHandler.error1(56, this.fStringPool.addString(Integer.toHexString(var1)));
  1946.                      }
  1947.  
  1948.                      ++var3;
  1949.                      if (var3 == var4) {
  1950.                         this.savePartialMultiByte(3, 0, var11, var10);
  1951.                         this.fOverflowOffset = var3;
  1952.                         this.fOutputOffset = var6;
  1953.                         this.fPartialMultiByteResult = true;
  1954.                         return false;
  1955.                      }
  1956.  
  1957.                      var12 = var2[var3];
  1958.                   }
  1959.  
  1960.                   if ((var12 & 192) != 128) {
  1961.                      this.fErrorHandler.error4(59, this.fStringPool.addString(Integer.toHexString(var1)), this.fStringPool.addString(Integer.toHexString(var10)), this.fStringPool.addString(Integer.toHexString(var11)), this.fStringPool.addString(Integer.toHexString(var12)));
  1962.                   }
  1963.                }
  1964.             case 4:
  1965.                switch (var9) {
  1966.                   case 0:
  1967.                      var5[var6++] = var1;
  1968.                      if (var6 == var7) {
  1969.                         this.savePartialMultiByte(4, 1, var12, var11, var10);
  1970.                         this.fOverflowOffset = var3;
  1971.                         this.fOutputOffset = var6;
  1972.                         this.fPartialMultiByteResult = false;
  1973.                         return false;
  1974.                      }
  1975.                   case 1:
  1976.                      var5[var6++] = var10;
  1977.                      if (var6 == var7) {
  1978.                         this.savePartialMultiByte(4, 2, var12, var11, var10);
  1979.                         this.fOverflowOffset = var3;
  1980.                         this.fOutputOffset = var6;
  1981.                         this.fPartialMultiByteResult = false;
  1982.                         return false;
  1983.                      }
  1984.                   case 2:
  1985.                      var5[var6++] = var11;
  1986.                      if (var6 == var7) {
  1987.                         this.savePartialMultiByte(4, 3, var12, var11, var10);
  1988.                         this.fOverflowOffset = var3;
  1989.                         this.fOutputOffset = var6;
  1990.                         this.fPartialMultiByteResult = false;
  1991.                         return false;
  1992.                      }
  1993.                   case 3:
  1994.                      var5[var6++] = var12;
  1995.                      if (var6 == var7) {
  1996.                         this.fOverflowOffset = var3;
  1997.                         this.fOutputOffset = var6;
  1998.                         this.fPartialMultiByteResult = false;
  1999.                         return false;
  2000.                      }
  2001.                   default:
  2002.                      if (var8 < 4) {
  2003.                         ++var3;
  2004.                         if (var3 == var4) {
  2005.                            this.fOverflowOffset = var3;
  2006.                            this.fOutputOffset = var6;
  2007.                            this.fPartialMultiByteResult = true;
  2008.                            return false;
  2009.                         }
  2010.                      }
  2011.                }
  2012.          }
  2013.  
  2014.          this.fOverflowOffset = var3;
  2015.          this.fOutputOffset = var6;
  2016.          return true;
  2017.       }
  2018.    }
  2019. }
  2020.